Miranda.c

Go to the documentation of this file.

#include "derivative.h"
#include "utils.h" /* For Parity */
#include "Miranda.h"
#include "DSPI.h"
#include <limits.h> /* To set limits */
#include <stdlib.h>
/*
 ******************************************************************************
 * constants
 ******************************************************************************
 */

const uint16_t cau16MirandaReset[] = 
{
  /* Sequence below is needed to perform a soft-reset */
                /* Protocol 0 */
  (MIRANDA_DEVCTL | (MIRANDA_WRITE_REGISTER  << CHAR_BIT)),(0x0080u),
  (MIRANDA_DEVCTL | (MIRANDA_WRITE_REGISTER  << CHAR_BIT)),(0x00C0u),
  (MIRANDA_DEVCTL | (MIRANDA_WRITE_REGISTER  << CHAR_BIT)),(0x0040u),
            /* Protocol 1 */
  ((MIRANDA_DEVCTL >> 4u) | ((MIRANDA_WRITE_REGISTER >> 1u) << CHAR_BIT)),(0x0080u),
  ((MIRANDA_DEVCTL >> 4u) | ((MIRANDA_WRITE_REGISTER >> 1u) << CHAR_BIT)),(0x00C0u),
  ((MIRANDA_DEVCTL >> 4u) | ((MIRANDA_WRITE_REGISTER >> 1u) << CHAR_BIT)),(0x0040u),  
        /* Protocol 2 */
  (MIRANDA_DEVCTL_P2 | (MIRANDA_WRITE_REGISTER  << CHAR_BIT)),(0x8000u),
  (MIRANDA_DEVCTL_P2 | (MIRANDA_WRITE_REGISTER  << CHAR_BIT)),(0xC000u),
  (MIRANDA_DEVCTL_P2 | (MIRANDA_WRITE_REGISTER  << CHAR_BIT)),(0x4000u)    
};
  
const uint16_t cau16MirandaReadAllRegisters[] = 
{
           /* Protocol 0 */             
  (MIRANDA_SN_0     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_SN_1     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_ID_0     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_ID_1     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_DEVCFG_0 | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_DEVCFG_1 | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_CD_0C    | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_CD_0E    | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_CD_10    | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_CD_12    | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_CD_14    | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_CD_16    | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_CD_18    | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_CD_1A    | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_CD_1C    | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_CD_1E    | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),
  (MIRANDA_DEVSTAT  | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_DEVCTL   | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_TEST     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_RATE_X   | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),  
  (MIRANDA_ACC_Y    | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),
  (MIRANDA_ACC_Z    | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_TEMP     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),  
  (MIRANDA_COUNT    | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),
           /* Protocol 1 */ 
  ((MIRANDA_SN_0 >> 4u)     | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_SN_1 >> 4u)     | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_ID_0 >> 4u)     | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_ID_1 >> 4u)     | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_DEVCFG_0 >> 4u) | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_DEVCFG_1 >> 4u) | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_CD_0C >> 4u)    | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_CD_0E >> 4u)    | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_CD_10 >> 4u)    | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_CD_12 >> 4u)    | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_CD_14 >> 4u)    | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_CD_16 >> 4u)    | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_CD_18 >> 4u)    | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_CD_1A >> 4u)    | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_CD_1C >> 4u)    | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_CD_1E >> 4u)    | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR),
  ((MIRANDA_DEVSTAT >> 4u)  | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_DEVCTL >> 4u)   | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_TEST >> 4u)     | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_RATE_X >> 4u)   | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR),  
  ((MIRANDA_ACC_Y >> 4u)    | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR),
  ((MIRANDA_ACC_Z >> 4u)    | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR), 
  ((MIRANDA_TEMP >> 4u)     | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR),  
  ((MIRANDA_COUNT >> 4u)    | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR),  
           /* Protocol 2 */
  (MIRANDA_BANK_P2      | (MIRANDA_WRITE_REGISTER << CHAR_BIT)),(CLEAR),  
  (MIRANDA_RATE_X_P2    | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_ACC_Y_P2     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_ACC_Z_P2     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_TEMP_P2      | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_BANK_P2      | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_TEST_P2      | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_RESET_P2     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_SENS_SYNC_P2 | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_DEVSTAT_P2   | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_DEVCTL_P2    | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_COUNT_P2     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_DEV_ID_P2    | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),
  (MIRANDA_BANK_P2      | (MIRANDA_WRITE_REGISTER << CHAR_BIT)),(0x0200u),
  (MIRANDA_SN_0_P2      | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_SN_1_P2      | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_ID_0_P2      | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_ID_1_P2      | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),
  (MIRANDA_DEVCFG_0_P2  | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_DEVCFG_1_P2  | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_CD_0C_P2     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_CD_0E_P2     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),  
  (MIRANDA_CD_10_P2     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),
  (MIRANDA_CD_12_P2     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_CD_14_P2     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),  
  (MIRANDA_CD_16_P2     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),
  (MIRANDA_CD_18_P2     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),
  (MIRANDA_CD_1A_P2     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR), 
  (MIRANDA_CD_1C_P2     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),  
  (MIRANDA_CD_1E_P2     | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR)    
};

const uint16_t cau16MirandaPerformAccelReading[] = 
{
           /* Protocol 0 */             
  (MIRANDA_RATE_X  | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),
  (MIRANDA_ACC_Y   | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),
  (MIRANDA_ACC_Z   | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),
           /* Protocol 1 */             
  ((MIRANDA_RATE_X >> 4u)  | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR),
  ((MIRANDA_ACC_Y >> 4u)   | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR),
  ((MIRANDA_ACC_Z >> 4u)   | ((MIRANDA_READ_REGISTER | 0x80u)  << CHAR_BIT)),(CLEAR),
       /* Protocol 2 */         
  (MIRANDA_RATE_X_P2  | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),
  (MIRANDA_ACC_Y_P2   | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR),
  (MIRANDA_ACC_Z_P2   | (MIRANDA_READ_REGISTER  << CHAR_BIT)),(CLEAR)
};

const uint16_t cau16MirandaPerformAccelReadingSPI[] = 
{
       /* Protocol 1 only */            
  (MIRANDA_READ_ACCEL | MIRANDA_READ_X),(CLEAR),
  (MIRANDA_READ_ACCEL | MIRANDA_READ_Y),(CLEAR),
  (MIRANDA_READ_ACCEL | MIRANDA_READ_Z),(CLEAR)
};
 
 /*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
/*
 ******************************************************************************
 * u8fnMirandaReadRegister
 ******************************************************************************
 */
uint8_t u8fnMirandaReadRegister(const uint8_t cu8DSPIInstance, \
                                const uint8_t cu8ChipSelect,   \
                                uint16_t u16Register,          \
                                uint16_t* pu16DataRead,        \
                                const uint8_t cu8Protocol)
{
  uint8_t u8Status;
  uint8_t u8RegisterOperationProtocol;
  
  u8Status = CLEAR;
          
  if (PROTOCOL_1 == cu8Protocol)
  {
    u8RegisterOperationProtocol = MIRANDA_READ_REGISTER | 0x80u;
    u16Register = (u16Register >> 4u);
  }
  else if ((PROTOCOL_0 == cu8Protocol) || (PROTOCOL_2 == cu8Protocol))
  {
    u8RegisterOperationProtocol = MIRANDA_READ_REGISTER;
  }       
  else
  {
        u8Status = MIRANDA_ERROR_PROTOCOL;
  }
          
  if (CLEAR == u8Status)
  {        
     u8Status = u8fnMirandaRegisterOperation(u8RegisterOperationProtocol, cu8DSPIInstance,   \
                                             cu8ChipSelect, u16Register, CLEAR,              \
                                             pu16DataRead, cu8Protocol);
  }
  
  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnMirandaWriteRegister
 ******************************************************************************
 */
uint8_t u8fnMirandaWriteRegister(const uint8_t cu8DSPIInstance, \
                                 const uint8_t cu8ChipSelect,   \
                                 uint16_t u16Register,          \
                                 uint16_t u16ValueToWrite,      \
                                 uint16_t* pu16DataRead,        \
                                 const uint8_t cu8Protocol)
{
  uint8_t u8Status;
  uint8_t u8RegisterOperationProtocol;
  
  u8Status = CLEAR;
          
  if (PROTOCOL_1 == cu8Protocol)
  {
    u8RegisterOperationProtocol = MIRANDA_WRITE_REGISTER >> 1;
    u16Register = (u16Register >> 4u);    
  }
  else if ((PROTOCOL_0 == cu8Protocol) || (PROTOCOL_2 == cu8Protocol))
  {        
        u8RegisterOperationProtocol = MIRANDA_WRITE_REGISTER;
  }       
  else
  {
        u8Status = MIRANDA_ERROR_PROTOCOL;
  }
           
  if (CLEAR == u8Status)
  {
     u8Status = u8fnMirandaRegisterOperation(u8RegisterOperationProtocol, cu8DSPIInstance,  \
                                             cu8ChipSelect, u16Register, u16ValueToWrite,   \
                                             pu16DataRead, cu8Protocol);
  }
  
  return (u8Status);  
}
/*
 ******************************************************************************
 * u8fnMirandaReset
 ******************************************************************************
 */
uint8_t u8fnMirandaReset(const uint8_t cu8DSPIInstance, \
                         const uint8_t cu8ChipSelect,   \
                         const uint8_t cu8Protocol)
{
  uint8_t u8Status;
  uint8_t u8Index;
  uint16_t au16Result[N_ELEMENTS(cau16MirandaReset)/3u];
  
  u8Status = CLEAR;
  u8Index = cu8Protocol * N_ELEMENTS(cau16MirandaReset)/3u;
  
  
  u8Status = u8fnMirandaBatchOp(cu8DSPIInstance, cu8ChipSelect,             \
                                (uint16_t*)&cau16MirandaReset[u8Index],     \
                                (uint16_t*)au16Result,                      \
                                (uint8_t)N_ELEMENTS(au16Result),            \
                                cu8Protocol);
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnMirandaReadAccelRegisters
 ******************************************************************************
 */
uint8_t u8fnMirandaReadAccelRegisters(const uint8_t cu8DSPIInstance, \
                                      const uint8_t cu8ChipSelect,   \
                                      const uint8_t cu8Protocol)
{
  uint8_t u8Status;
  uint8_t u8Index;
  uint16_t au16Result[N_ELEMENTS(cau16MirandaPerformAccelReading)];
  
  u8Status = CLEAR;
  u8Index = cu8Protocol * N_ELEMENTS(cau16MirandaPerformAccelReading)/3;
  
  u8Status = u8fnMirandaBatchOp(cu8DSPIInstance, cu8ChipSelect,                       \
                                (uint16_t*)&cau16MirandaPerformAccelReading[u8Index], \
                                (uint16_t*)au16Result,                                \
                                (uint8_t)N_ELEMENTS(au16Result),                      \
                                cu8Protocol);
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnMirandaReadAllRegisters
 ******************************************************************************
 */
uint8_t u8fnMirandaReadAllRegisters(const uint8_t cu8DSPIInstance, \
                                    const uint8_t cu8ChipSelect,   \
                                    const uint8_t cu8Protocol)
{
  uint8_t u8Status;
  uint8_t u8Index;
  uint8_t u8Size;
  uint16_t au16Result[N_ELEMENTS(cau16MirandaReadAllRegisters)];
 
  u8Status = CLEAR;
  u8Index = cu8Protocol * (1 + MIRANDA_MEMORY_MAP_SIZE/2);
  
  if(PROTOCOL_2 != cu8Protocol)
  {
          u8Size = 1 + MIRANDA_MEMORY_MAP_SIZE/2;
  }
  else
  {
          /* Number of registers with Protocol 2 + 2 WRITE operations to choose the bank */
          u8Size = 30;
  }
  
  u8Status = u8fnMirandaBatchOp(cu8DSPIInstance, cu8ChipSelect,                    \
                                (uint16_t*)&cau16MirandaReadAllRegisters[u8Index], \
                                (uint16_t*)au16Result,                             \
                                (uint8_t)u8Size,                                   \
                                cu8Protocol);
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnMirandReadAccelSPI
 ******************************************************************************
 */
uint8_t u8fnMirandaReadAccelSPI(const uint8_t cu8DSPIInstance, \
                                const uint8_t cu8ChipSelect,   \
                                const uint8_t cu8Axis,         \
                                uint16_t* pu16AccelResults)

{
  uint8_t u8Index;
  uint8_t u8Status;
  uint8_t u8Counter;
  uint16_t au16MirandaPerformAccelReading[6];
   
  u8Status  = CLEAR;
  u8Index   = CLEAR;
  u8Counter = CLEAR;

    if(MIRANDA_READ_X & cu8Axis)
    {
        au16MirandaPerformAccelReading[u8Index] = cau16MirandaPerformAccelReadingSPI[0];
        au16MirandaPerformAccelReading[++u8Index] = cau16MirandaPerformAccelReadingSPI[1]; 
        u8Index++;
        u8Counter++;            
    } 
    if(MIRANDA_READ_Y & cu8Axis)
    {
        au16MirandaPerformAccelReading[u8Index] = cau16MirandaPerformAccelReadingSPI[2];
        au16MirandaPerformAccelReading[++u8Index] = cau16MirandaPerformAccelReadingSPI[3];
        u8Index++;              
        u8Counter++;
    }
    if(MIRANDA_READ_Z & cu8Axis)
    {
        au16MirandaPerformAccelReading[u8Index] = cau16MirandaPerformAccelReadingSPI[4];
        au16MirandaPerformAccelReading[++u8Index] = cau16MirandaPerformAccelReadingSPI[5];
        u8Counter++;
    }
    if(CLEAR == (MIRANDA_READ_X & cu8Axis || MIRANDA_READ_Y & cu8Axis || MIRANDA_READ_Z & cu8Axis))
    {
        /* Request X-axis reading otherwise */
        au16MirandaPerformAccelReading[u8Index] = cau16MirandaPerformAccelReadingSPI[0];
        au16MirandaPerformAccelReading[++u8Index] = cau16MirandaPerformAccelReadingSPI[1];
        u8Counter++;            
    }
    
    u8Status = u8fnMirandaBatchOp(cu8DSPIInstance, cu8ChipSelect,  \
               (const uint16_t*)&au16MirandaPerformAccelReading[0],  \
                pu16AccelResults, u8Counter, PROTOCOL_1);
    
    u8Status |= u8fnMirandaExtractAccelResponse(pu16AccelResults, \
                                                pu16AccelResults, \
                                                u8Counter);
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnMirandaBatchOp
 ******************************************************************************
 */
uint8_t u8fnMirandaBatchOp(const uint8_t cu8DSPIInstance,        \
                           const uint8_t cu8ChipSelect,          \
                           const uint16_t* pu16DataToSend,       \
                           uint16_t* pu16UnfilteredDataReceived, \
                           uint8_t u8Size,                       \
                           const uint8_t cu8Protocol)
{
  uint8_t  u8Status;
  uint8_t u8CRC8;
  uint16_t u16Counter;
  uint16_t u16TimeOut;
  uint16_t u16CurrentWordToSend[2u];
  uint16_t u16FirstWordReceived;
  uint32_t u32WordToCheckParity;
  
  /* Init locals */
  u8Status   = CLEAR;
  u16Counter = CLEAR;
  u16TimeOut = CLEAR;
  u16CurrentWordToSend[0] = CLEAR;
  u16CurrentWordToSend[1] = CLEAR;  
  u16FirstWordReceived = CLEAR;

  
  /* Use DSPI to send config - we need to send one more word since the result*/
  /* will be sent with the second one. The content of the last word is       */
  /* irrelevant.                                                             */
  
  /* First, send the first word and simply ignore whatever is received */
  /* Check parity if Protocol 0 */
  if (PROTOCOL_0 == cu8Protocol)
  {
          u32WordToCheckParity = (uint32_t)(*pu16DataToSend << 16u) | (uint32_t)(*(pu16DataToSend+1));
          u16CurrentWordToSend[0] = u16fnMirandaAddParityToCommand(u32WordToCheckParity);
          u16CurrentWordToSend[1] = *(++pu16DataToSend);
  }
  else if (PROTOCOL_1 == cu8Protocol)
  {
          u16CurrentWordToSend[0] = *pu16DataToSend;
          u16CurrentWordToSend[1] = *(++pu16DataToSend);
  }
  else if (PROTOCOL_2 == cu8Protocol)
  {
          u16CurrentWordToSend[0] = *pu16DataToSend;      
          u32WordToCheckParity = (uint32_t)(*pu16DataToSend << 16u) | (uint32_t)(*(pu16DataToSend+1));
          u8CRC8 = u8fnCRC8((uint8_t*) &u32WordToCheckParity, 0x1D, 24, CLEAR);
          u16CurrentWordToSend[1] = *(++pu16DataToSend)| (uint16_t) u8CRC8;                                         
  }  
  else 
  {
          u8Status = MIRANDA_ERROR_PROTOCOL;  
  }
  
  if (CLEAR == u8Status)
  {
  u8Status = u8fnDSPITranscieve(cu8DSPIInstance, cu8ChipSelect,           \
                                (uint16_t*)&u16CurrentWordToSend[0],      \
                                (uint16_t*)&u16FirstWordReceived, 2u);
 
                                
  /* Next, we shall send the rest of the datagram and store the read-back    */
  for(u16Counter = 1u; u16Counter < u8Size; u16Counter++)
  {
    /* Only proceed if we are clear to go */
    if(CLEAR == u8Status)
    {
      /* Check parity if Protocol 0 */
      if (PROTOCOL_0 == cu8Protocol)
      {
          u32WordToCheckParity = (uint32_t)(*pu16DataToSend << 16u) | (uint32_t)(*(pu16DataToSend+1));
          u16CurrentWordToSend[0] = u16fnMirandaAddParityToCommand(u32WordToCheckParity);
          u16CurrentWordToSend[1] = *(++pu16DataToSend);
      }
      else if (PROTOCOL_1 == cu8Protocol)
      {
          u16CurrentWordToSend[0] = *pu16DataToSend;
          u16CurrentWordToSend[1] = *(++pu16DataToSend);
      }
      else if (PROTOCOL_2 == cu8Protocol)
      {
          u16CurrentWordToSend[0] = *pu16DataToSend;
          u32WordToCheckParity = (uint32_t)(*pu16DataToSend << 16u) | (uint32_t)(*(pu16DataToSend+1));
          u8CRC8 = u8fnCRC8((uint8_t*) &u32WordToCheckParity, 0x1D, 24, CLEAR);
          u16CurrentWordToSend[1] = *(++pu16DataToSend)| (uint16_t) u8CRC8;             
      }  
      
      /* We must wait for the previous transmission to end before launching  */
      /* a new one. We must also make sure we don't stay here forever.       */
      u16TimeOut = CLEAR;
      while((u8fnIsDSPIBusy(cu8DSPIInstance >> 4u)) && \
            (USHRT_MAX > u16TimeOut))
      {
        u16TimeOut++;
      }
      
      /* If we came out of the above wait without expiring the timer, we     */
      /* should continue. otherwise, flag as an error.                       */
      if((USHRT_MAX) > u16TimeOut)
      {
        u8Status = u8fnDSPITranscieve(cu8DSPIInstance, cu8ChipSelect,        \
                                      (uint16_t*)&u16CurrentWordToSend[0],   \
                                      pu16UnfilteredDataReceived++, 2u);
      }
      else
      {
        /* There's something wrong */
        u8Status = MIRANDA_TIMED_OUT;
      }
    }
    else
    {
      /* Loop til we exit */
    }
  }
  
  /* Only go on if we still can */
  if(CLEAR == u8Status)
  {
    /* Dummy write just to get the last response */
    /* Check parity if Protocol 0 */
    if (PROTOCOL_0 == cu8Protocol)
    {
          u32WordToCheckParity = (uint32_t)(MIRANDA_SN_0 << 16u) | (uint32_t)CLEAR;
          u16CurrentWordToSend[0] = u16fnMirandaAddParityToCommand(u32WordToCheckParity);  
          u16CurrentWordToSend[1] = (uint16_t)CLEAR;
    }
    else if (PROTOCOL_1 == cu8Protocol)
    {
          u16CurrentWordToSend[0] = ((MIRANDA_SN_0 >> 4u) | ((MIRANDA_READ_REGISTER | 0x80u) << CHAR_BIT));
          u16CurrentWordToSend[1] = (uint16_t)CLEAR;
    }      
    else if (PROTOCOL_2 == cu8Protocol)
    {
          u32WordToCheckParity = (uint32_t)(MIRANDA_BANK_P2 << 16u) | (uint32_t)CLEAR;
          u16CurrentWordToSend[0] = MIRANDA_BANK_P2;
          u8CRC8 = u8fnCRC8((uint8_t*) &u32WordToCheckParity, 0x1D, 24, CLEAR);
          u16CurrentWordToSend[1] = (uint16_t) u8CRC8;          
    }           
    
    /* If we came out of the above wait without expiring the timer, we       */
    /* should continue. otherwise, flag as an error.                         */
    u16TimeOut = CLEAR;
    while((u8fnIsDSPIBusy(cu8DSPIInstance >> 4u)) && \
          (USHRT_MAX > u16TimeOut))
    {
      u16TimeOut++;
    }
    /* If we came out of the above wait without expiring the timer, we       */
    /* should continue. otherwise, flag as an error.                         */
    if((USHRT_MAX) > u16TimeOut)
    {
      u8Status = u8fnDSPITranscieve(cu8DSPIInstance, cu8ChipSelect,      \
                                    (uint16_t*)&u16CurrentWordToSend[0], \
                                    pu16UnfilteredDataReceived, 2u);
    }
    else
    {
      /* There's something wrong */
      u8Status = MIRANDA_TIMED_OUT;
    }
  }
  else
  {
    /* Just get out of here please */
  } /* end if (CLEAR == u8Status), the second one */
  } /* end if (CLEAR == u8Status), the first one */ 
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnMMA6800ExtractRegisterResponse
 ******************************************************************************
 */
uint8_t u8fnMirandaExtractRegisterResponse(const uint16_t* pu16RawResponse, \
                                           uint16_t* pu16Response,            \
                                           uint8_t u8Size,                  \
                                           const uint8_t cu8Protocol)
{
  /* Declare local variables */
  uint8_t u8Status;
  uint8_t u8Counter;
  uint32_t u32LocalDataReceived;
  
  /* Init local variables */
  u8Status  = CLEAR;
  u8Counter = CLEAR;
  
  for(; u8Counter < u8Size; u8Counter++)
  {

        u32LocalDataReceived = (uint32_t)(*pu16RawResponse << 16) | \
                               (uint32_t)(*(pu16RawResponse+1));
    u8Status = u8fnMirandaErrorResponseAnalysis(u32LocalDataReceived, cu8Protocol);       
    
    if (CLEAR == u8Status)
    {
        if (PROTOCOL_0 == cu8Protocol)
        {
          /* Data comes in the lower 16-bits according to the spec */
          *pu16Response = *(pu16RawResponse+1);
        }
        else if (PROTOCOL_1 == cu8Protocol)
        {
          /* Data shifted in the lower 16-bits according to the spec */
          *pu16Response = (*pu16RawResponse << 11) | (*(pu16RawResponse+1) >> 5);
        }
        else if (PROTOCOL_2 == cu8Protocol)
        {
          /* Data shifted in the lower 16-bits according to the spec */
                *pu16Response = (*pu16RawResponse << 8) | (*(pu16RawResponse+1) >> 8);
        }
        else
        {
                u8Status = MIRANDA_ERROR_PROTOCOL;
        }
    }
    else
    {
      *pu16Response = CLEAR;
    }

    pu16RawResponse++;
    pu16Response++;
  }
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnMirandaExtractAccelResponse
 ******************************************************************************
 */
uint8_t u8fnMirandaExtractAccelResponse(const uint16_t* pu16RawResponse, \
                                        uint16_t* pu16Response,          \
                                        uint8_t u8Size)
{
  /* Declare local variables */
  uint8_t u8Status;
  uint8_t u8Counter;
  uint32_t u32WordToCheckParity;
  
  /* Init local variables */
  u8Status  = CLEAR;
  u8Counter = CLEAR;
  
  for(; u8Counter < u8Size; u8Counter++)
  {
    /* Check Parity */
        u32WordToCheckParity = (uint32_t)(*pu16RawResponse << 16u) | (uint32_t)(*(pu16RawResponse+1));  
    if(CLEAR == u32fnCheckOddParity(u32WordToCheckParity, CLEAR))       
    {
      /* Is this Normal Response */
      if(CLEAR != (BIT26 && u32WordToCheckParity))
      {
       u8Status = CLEAR;
       *pu16Response = ((*pu16RawResponse & MIRANDA_RAW_INERTIAL_MASK_UPPER) << 6) |    \
                       ((*(pu16RawResponse+1) & MIRANDA_RAW_INERTIAL_MASK_LOWER) >> 10);
      }
      else
      {
         /* Identify any errors */
         if(MIRANDA_INTERNAL_ERROR == (MIRANDA_EXCEPTION_MASK & *(pu16RawResponse+1)))
         {
           /* Internal error must be reported */
           u8Status = MIRANDA_INTERNAL_ERROR;
         }
         else if (MIRANDA_SPI_FAULT == (MIRANDA_EXCEPTION_MASK & *(pu16RawResponse+1)))
         {
           /* SPI transfer fault must be reported */            
           u8Status = MIRANDA_SPI_FAULT;        
         }
         else if (MIRANDA_MISO_COMPARE_FAULT == (MIRANDA_EXCEPTION_MASK & *(pu16RawResponse+1)))
         {
           /* MISO data compare fault must be reported */       
           u8Status = MIRANDA_MISO_COMPARE_FAULT;       
         }        
         *pu16Response = 0xFFFF;
       }        
    }
    else
    {
      /* If invalid parity is found, clear this particular response, */
      /* and make sure to flag it in the status byte.                */
      u8Status |= MIRANDA_INVALID_PARITY;
      *pu16Response = 0xFFFE;
    }
    
    pu16RawResponse++;
    pu16Response++;
  }
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnMirandaRegisterOperation
 ******************************************************************************
 */
static uint8_t u8fnMirandaRegisterOperation(const uint8_t u8RegisterOperation,\
                                            const uint8_t cu8DSPIInstance,    \
                                            const uint8_t cu8ChipSelect,      \
                                            uint16_t u16Register,             \
                                            const uint16_t u16ValueToWrite,   \
                                            uint16_t* pu16DataRead,           \
                                            const uint8_t cu8Protocol)
{
  uint8_t  u8Status;
  uint8_t  u8RegisterAdressStatus;
  uint8_t  u8CRC8;
  uint16_t u16Counter;
  uint16_t au16LocalDataReceived[4u];
  uint16_t au16LocalDataToSend[4u];
  uint32_t u32WordToCheckParity;  
  uint32_t u32LocalDataReceived;
  
  /* Init locals */
  u8Status                  = CLEAR;
  u16Counter                = CLEAR;
  au16LocalDataReceived[0u] = CLEAR;
  au16LocalDataReceived[1u] = CLEAR;
  au16LocalDataReceived[2u] = CLEAR;
  au16LocalDataReceived[3u] = CLEAR;
  
  /* Format the MOSI message according to Protocol used */
  if (PROTOCOL_0 == cu8Protocol)
  {
    au16LocalDataToSend[0u]   = u16Register;
    au16LocalDataToSend[1u]   = u16ValueToWrite;
    /* Second sending to receive MISO response expected */  
    au16LocalDataToSend[2u]   = u16Register;
    au16LocalDataToSend[3u]   = CLEAR;
    /* Mask the register address with the appropriate command */
    au16LocalDataToSend[0u] |= (u8RegisterOperation   << CHAR_BIT);
    au16LocalDataToSend[2u] |= (MIRANDA_READ_REGISTER << CHAR_BIT);
    /* Check/Add parity bit */
        u32WordToCheckParity = (uint32_t)(au16LocalDataToSend[0u] << 16u) | \
                               (uint32_t)(au16LocalDataToSend[1u]);
        au16LocalDataToSend[0u] = u16fnMirandaAddParityToCommand(u32WordToCheckParity);
    /* Check/Add parity bit */
        u32WordToCheckParity = (uint32_t)(au16LocalDataToSend[2u] << 16u) | \
                               (uint32_t)(au16LocalDataToSend[3u]);
        au16LocalDataToSend[2u] = u16fnMirandaAddParityToCommand(u32WordToCheckParity);
        /* Check if register to handle is within the memory map and register address is even*/
        u8RegisterAdressStatus = ((MIRANDA_MEMORY_MAP_SIZE > (u16Register >> 5u)) && \
                                          (CLEAR == ((u16Register >> 5u) & BIT0)));
  }
  else if (PROTOCOL_1 == cu8Protocol)
  {
    au16LocalDataToSend[0u]   = u16Register;
    au16LocalDataToSend[1u]   = u16ValueToWrite;
    /* Second sending to receive MISO response expected */  
    au16LocalDataToSend[2u]   = u16Register;
    au16LocalDataToSend[3u]   = CLEAR;
    /* Mask the register address with the appropriate command */
    au16LocalDataToSend[0u] |= (u8RegisterOperation   << CHAR_BIT);
    au16LocalDataToSend[2u] |= ((MIRANDA_READ_REGISTER | 0x80u) << CHAR_BIT);
        /* Check if register to handle is within the memory map and register address is even*/    
        u8RegisterAdressStatus = ((MIRANDA_MEMORY_MAP_SIZE > u16Register) && \
                                          (CLEAR == (u16Register & BIT0)));
  }    
  else if (PROTOCOL_2 == cu8Protocol)
  {
    au16LocalDataToSend[0u]   = u16Register | (u16ValueToWrite >> 8);
    au16LocalDataToSend[1u]   = u16ValueToWrite << 8;
    /* Second sending to receive MISO response expected */  
    au16LocalDataToSend[2u]   = u16Register;
    au16LocalDataToSend[3u]   = CLEAR;
    /* Mask the register address with the appropriate command */
    au16LocalDataToSend[0u] |= (u8RegisterOperation   << CHAR_BIT);
    au16LocalDataToSend[2u] |= (MIRANDA_READ_REGISTER << CHAR_BIT);
    /* Add CRC word */
        u32WordToCheckParity = (uint32_t)(au16LocalDataToSend[0u] << 16u) | \
                               (uint32_t)(au16LocalDataToSend[1u]);
        u8CRC8 = u8fnCRC8((uint8_t*) &u32WordToCheckParity, 0x1D, 24, CLEAR);
        au16LocalDataToSend[1] = au16LocalDataToSend[1] | (uint16_t) u8CRC8;
    /* Add CRC word */
        u32WordToCheckParity = (uint32_t)(au16LocalDataToSend[2u] << 16u) | \
                               (uint32_t)(au16LocalDataToSend[3u]);
        u8CRC8 = u8fnCRC8((uint8_t*) &u32WordToCheckParity, 0x1D, 24, CLEAR);
        au16LocalDataToSend[3] = au16LocalDataToSend[3] | (uint16_t) u8CRC8;
        /* Check if register to handle is within the memory map*/       
        u8RegisterAdressStatus = ((MIRANDA_MEMORY_MAP_SIZE_P2 > (u16Register >> 10u)));
        
  }  
  else
  {
        u8Status = MIRANDA_ERROR_PROTOCOL;
  }
    
  
  /* Only continue if the requested read is within the valid memory-map */
  if(u8RegisterAdressStatus && (CLEAR == u8Status))
  { 
    /* Use DSPI to send config - we need to send two words since the result  */
    /* will be sent with the second one. The content of the second one is    */
    /* irrelevant.                                                           */
    u8Status = u8fnDSPITranscieve(cu8DSPIInstance, cu8ChipSelect,        \
                                  (uint16_t*)&au16LocalDataToSend,       \
                                  (uint16_t*)au16LocalDataReceived, 4u);
    if(CLEAR == u8Status)
    {
      while((DSPI_BUSY_WITH_PREVIOUS_TX ==             \
             u8fnIsDSPIBusy(cu8DSPIInstance >> 4u)) && \
            ((USHRT_MAX) > u16Counter))
      {
        /* Wait here for result until we time-out or we get data */
        u16Counter++;
      } /* End while */
      if(USHRT_MAX > u16Counter)
      {
        /* Check for any flagged errors */
        u32LocalDataReceived = (uint32_t)(au16LocalDataReceived[2u] << 16) | \
                               (uint32_t)au16LocalDataReceived[3u];
        u8Status = u8fnMirandaErrorResponseAnalysis(u32LocalDataReceived, cu8Protocol);
      
        if(CLEAR == u8Status)
        {
                if (PROTOCOL_0 == cu8Protocol)
                {
              /* Data comes in the lower 16-bits according to the spec */
              *pu16DataRead = au16LocalDataReceived[3u];
                }
                else if (PROTOCOL_1 == cu8Protocol)
                {
              /* Data shifted in the lower 16-bits according to the spec */
              *pu16DataRead = (uint16_t)(u32LocalDataReceived >> 5);
                }
                else if (PROTOCOL_2 == cu8Protocol)
                {
              /* Data shifted in the lower 16-bits according to the spec */
              *pu16DataRead = (uint16_t)(u32LocalDataReceived >> 8);
                }
                else
                {
                        u8Status = MIRANDA_ERROR_PROTOCOL;
                }
        }
        else
        {
          /* Exit with error as marked by u8fnMirandaErrorResponseAnalysis */
        }
      } /* End if no time-out */
      else
      {
        /* We timed-out. Exit with an error */
        u8Status = MIRANDA_TIMED_OUT;
      } /* End else - we had a time-out */
    } /* End if Status is clear */
    else
    {
      /* We need to exit with an error - already flagged */
    }
  } /* end if within memory map */
  else
  {
    u8Status = MIRANDA_INVALID_MEMORY_LOCATION;
  }
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnMirandaErrorResponseAnalysis
 ******************************************************************************
 */
static uint8_t u8fnMirandaErrorResponseAnalysis(const uint32_t cu32ReceivedWord,   \
                                                        const uint8_t cu8Protocol)
{
  uint8_t  u8Status;
  uint16_t cu16ReceivedWordUpper;
  uint16_t cu16ReceivedWordLower; 
  
  u8Status = CLEAR;
  
  cu16ReceivedWordUpper = (uint16_t) (cu32ReceivedWord >> 16);
  cu16ReceivedWordLower = (uint16_t) cu32ReceivedWord;
  
  if (PROTOCOL_0 == cu8Protocol)
  {
    /* Once data has been received, check its integrity, starting with     */
    /* parity */
    if(CLEAR == u32fnCheckOddParity(cu32ReceivedWord, CLEAR))
    {
      /* Identify any errors */
      if(MIRANDA_INTERNAL_ERROR == (MIRANDA_EXCEPTION_MASK & cu16ReceivedWordUpper))
      {
        /* Internal error must be reported */
        u8Status = MIRANDA_INTERNAL_ERROR;
      }
      else if (MIRANDA_SPI_FAULT == (MIRANDA_EXCEPTION_MASK & cu16ReceivedWordUpper))
      {
        /* SPI transfer fault must be reported */       
        u8Status = MIRANDA_SPI_FAULT;           
      }
      else if (MIRANDA_MISO_COMPARE_FAULT == (MIRANDA_EXCEPTION_MASK & cu16ReceivedWordUpper))
      {
        /* MISO data compare fault must be reported */          
        u8Status = MIRANDA_MISO_COMPARE_FAULT;          
      }
      else
      {
        /* We're good! */
      }
    }
    else
    {
      u8Status = MIRANDA_INVALID_PARITY;
    }
  }
  else if (PROTOCOL_1 == cu8Protocol)
  {
            /* Once data has been received, check its integrity, starting with     */
            /* parity */
            if(CLEAR == u32fnCheckOddParity(cu32ReceivedWord, CLEAR))
            {
              if (CLEAR == ((BIT30 | BIT29) & cu32ReceivedWord))
              {
                /* Identify any errors */
                if(MIRANDA_INTERNAL_ERROR == (MIRANDA_EXCEPTION_MASK & \
                                                     (cu16ReceivedWordLower >> 13)))
                {
                  /* Internal error must be reported */
                  u8Status = MIRANDA_INTERNAL_ERROR;
                }
                else if (MIRANDA_SPI_FAULT == (MIRANDA_EXCEPTION_MASK & \
                                                      (cu16ReceivedWordLower >> 13)))
                {
                  /* SPI transfer fault must be reported */     
                  u8Status = MIRANDA_SPI_FAULT;         
                }
                else if (MIRANDA_MISO_COMPARE_FAULT == (MIRANDA_EXCEPTION_MASK & \
                                                               (cu16ReceivedWordLower >> 13)))
                {
                  /* MISO data compare fault must be reported */        
                  u8Status = MIRANDA_MISO_COMPARE_FAULT;        
                }
                else
                {
                  /* We're good! */
                }
              }
              else
              {
                  /* We're good! */
              }
            }
            else
            {
              u8Status = MIRANDA_INVALID_PARITY;
            }           
  }
  else if (PROTOCOL_2 == cu8Protocol)
  {
            /* Once data has been received, check its integrity, starting with     */
            /* CRC */
            if(CLEAR == u8fnCRC8((uint8_t*) cu32ReceivedWord, 0x1D, 32, CLEAR))
            {
              if (CLEAR == ((BIT25 & cu32ReceivedWord) && (BIT24 & cu32ReceivedWord)))
              {   
                  u8Status = MIRANDA_EXCEPTION;
              }
              else
              {
                  /* We're good! */  
              }
            }
            else
            {
              u8Status = MIRANDA_INVALID_CRC;
            }           
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u16fnMirandaAddParityToCommand
 ******************************************************************************
 */
static uint16_t u16fnMirandaAddParityToCommand(uint32_t u32RawCommand)
{
  uint32_t u32Command;
  
  u32Command = CLEAR;

  u32Command = u32fnCheckOddParity(u32RawCommand, BIT19);
 
  return((uint16_t)(u32Command >> BITS_IN_16));
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */